package com.hp.easyBuy.controller;

import com.hp.easyBuy.contants.RedixKey;
import com.hp.easyBuy.contants.StatusCode;
import com.hp.easyBuy.entity.TUser;
import com.hp.easyBuy.service.UserService;
import com.hp.easyBuy.utils.R;
import com.hp.easyBuy.utils.VerifyCodeUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/*
 * 登录的控制器，负责接收前端的请求并响应结果给前端
 * 作者:代奥
 * 时间：2024年3月31日 14:02:15
 * */

@Controller
@RequestMapping("log")
public class LoginController {

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private UserService userService;



    //验证码功能，响应一个验证码图片给前端
    @RequestMapping("code")
    public void generateImageCode(String codeToken , HttpServletResponse resp) throws IOException {
        resp.setContentType("image/png");
        String code = VerifyCodeUtils.outputVerifyImage(220, 80, resp.getOutputStream(), 4);
        redisTemplate.opsForValue().set(RedixKey.CODE_ID+codeToken,code,5, TimeUnit.MINUTES);
    }

    //获取用户传来的用户名、姓名、真实姓名、验证码
    @RequestMapping("register")
    @ResponseBody
    public R register(@RequestBody TUser tuser, String code, String imageToken){
        //根据会话id从redis中获取验证码，并查看验证码是否正确
        Object strcode =  redisTemplate.opsForValue().get(RedixKey.CODE_ID + imageToken);
        //验证一次验证码之后，该验证码要作废，避免重复使用
        redisTemplate.delete(RedixKey.CODE_ID + imageToken);
        System.out.println("code = "+code);
        System.out.println("imageToken = "+imageToken);
        System.out.println("strcode = "+strcode);
        if(strcode == null){
            //redis当中没有验证码，证明验证码过期
            return R.error(StatusCode.ERROR1, "验证码过期");
        } else if (!code.equalsIgnoreCase((String)strcode)) {
            //验证码错误
            return R.error(StatusCode.ERROR2, "验证码错误");
        }
        //验证码正确，那么根据用户名获取用户对象，看是否重复
        TUser user = userService.getUserByUsercode(tuser.getUsercode());
        if(user != null){
            //不为null证明用户名已经存在
            return R.error(StatusCode.ERROR3, "用户名已存在");
        }else{
            //验证码成功，并且用户名未重复，那么就执行注册操作
            userService.register(tuser);
            //注册成功，将等同登录成功，将随机生成一个token
            String token = UUID.randomUUID().toString().replace("-", "");
            //数据脱敏
            tuser.setPassword(null);
            tuser.setSalt(null);
            //将token和用户对象存入redis当中,时效30分钟
            redisTemplate.opsForValue().set(RedixKey.LOGIN_USER+token,tuser,30,TimeUnit.MINUTES);
            //将该数据存入map当中，然后传给前段
            Map<String, Object> map = new HashMap<String,Object>();
            map.put("loginUser", tuser);
            map.put("token", token);
            System.out.println("map = "+map);
            return R.success(map);
        }
    }


    //登录功能，用于是用户登录
    @RequestMapping("login")
    @ResponseBody
    public R login(String usercode , String password ,String code,String imageToken){
        System.out.println("1111111");
        //根据会话id从redis中获取验证码，并查看验证码是否正确
        Object strcode =  redisTemplate.opsForValue().get(RedixKey.CODE_ID + imageToken);
        //验证一次验证码之后，该验证码要作废，避免重复使用
        redisTemplate.delete(RedixKey.CODE_ID + imageToken);
        if(strcode == null){
            //redis当中没有验证码，证明验证码过期
            return R.error(StatusCode.ERROR1, "验证码过期");
        } else if (!code.equalsIgnoreCase((String)strcode)) {
            //验证码错误
            return R.error(StatusCode.ERROR2, "验证码错误");
        }

        TUser loginUser = userService.login(usercode, password);
        if(loginUser == null){
            //为null说明登录失败
            return R.error(StatusCode.ERROR3, "用户名或者密码错误");
        } else if(loginUser.getStatus() == 1){
            //登录成功，将随机生成一个token
            String token = UUID.randomUUID().toString().replace("-", "");
            //数据脱敏
            loginUser.setPassword(null);
            loginUser.setSalt(null);
            //将token和用户对象存入redis当中,时效30分钟
            redisTemplate.opsForValue().set(RedixKey.LOGIN_USER+token,loginUser,30,TimeUnit.MINUTES);
            //将该数据存入map当中，然后传给前段
            Map<String, Object> map = new HashMap<String,Object>();
            map.put("loginUser", loginUser);
            map.put("token", token);
            return R.success(map);
        }else{
            return R.error(StatusCode.ERROR3, "用户已被冻结");
        }
    }



    //登录功能，用于是用户登录
    @RequestMapping("login2")
    @ResponseBody
    public R login2(String usercode , String password,HttpSession session){
        System.out.println("usercode = " + usercode);
        System.out.println("pwd = " + password);
        TUser loginUser = userService.login(usercode, password);
        if(loginUser == null){
            //为null说明登录失败
            return R.error(StatusCode.ERROR3, "用户名或者密码错误");
        } else if(loginUser.getStatus() == 1){
            //登录成功，将随机生成一个token
            String token = UUID.randomUUID().toString().replace("-", "");
            //数据脱敏
            loginUser.setPassword(null);
            loginUser.setSalt(null);
            //将token和用户对象存入redis当中,时效30分钟
            redisTemplate.opsForValue().set(RedixKey.LOGIN_USER+token,loginUser,30,TimeUnit.MINUTES);
            //将该数据存入map当中，然后传给前端
            Map<String, Object> map = new HashMap<String,Object>();
            map.put("loginUser", loginUser);
            map.put("token", token);
            return R.success(map);
        }else{
            return R.error(StatusCode.ERROR3, "用户已被冻结");
        }
    }

}
